{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c6a2bd60",
   "metadata": {},
   "source": [
    "# Tabm，一个自带集成特效的深度学习模型"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "382eb806",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "Tabm是一个可以用于结构化(tabular)数据的分类和回归任务的深度学习模型。\n",
    "\n",
    "它的名字是 Tabular  和 Multiple单词开头的拼接。\n",
    "\n",
    "含义是：A Tabular DL model that makes Multiple predictions。\n",
    "\n",
    "顾名思义，Tabm模型能够同时输出多个预测，并且取这些预测的平均作为最终的输出。\n",
    "\n",
    "这是一种非常经典的模型集成的思想，叫做bagging，就像随机森林做的那样。\n",
    "\n",
    "你可以这样大致理解Tabm的原理。\n",
    "\n",
    "1，Tabm由许多MLP小模型(例如k=32个)组成的，每个小模型都可以输出独立的预测，每个小模型的loss也是独立计算的。最终的预测是它们的预测结果的平均。\n",
    "\n",
    "2，为了减少总的权重参数规模，这些小模型有相当多的权重参数是共享的，因此Tabm的实际权重大小是显著小于许多个完全独立的小模型的，这种权重共享的设计实际上也起到了一定的正则化的作用，可以提升模型的效果。\n",
    "\n",
    "3，Tabm还引入了精心设计的对数值特征的PLREmbedding技术以及模型参数初始化方法，这些设计也能显著提升模型的效果。\n",
    "\n",
    "\n",
    "参考: https://github.com/yandex-research/tabm\n",
    "\n",
    "本范例我们使用Covertype数据集，它的目标是预测植被覆盖类型，是一个七分类问题。\n",
    "\n",
    "公众号**算法美食屋**后台回复关键词：torchkeras，获取本文notebook源码和所用Covertype数据集下载链接。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c04c9be-b192-43d0-a201-64960268c464",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install tabm \n",
    "!pip install torchkeras==4.0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75d03676-4a13-4a6d-bb46-326b47f21119",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "81c4a29a",
   "metadata": {},
   "source": [
    "## 一，准备数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "18d1cca2",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dfdata.shape =  (581012, 13)\n",
      "target_col =  Cover_Type\n",
      "cat_cols =  ['Wilderness_Area', 'Soil_Type']\n",
      "num_cols =  ['Elevation', 'Aspect', 'Slope', '...']\n",
      "len(dftrain) =  371847\n",
      "len(dfval) =  92962\n",
      "len(dftest) =  116203\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "import pandas as pd \n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "file_path = \"covertype.parquet\"\n",
    "dfdata = pd.read_parquet(file_path)\n",
    "\n",
    "cat_cols = ['Wilderness_Area', 'Soil_Type']\n",
    "num_cols = ['Elevation','Aspect','Slope','Horizontal_Distance_To_Hydrology',\n",
    " 'Vertical_Distance_To_Hydrology','Horizontal_Distance_To_Roadways',\n",
    " 'Hillshade_9am','Hillshade_Noon','Hillshade_3pm','Horizontal_Distance_To_Fire_Points']\n",
    "target_col = 'Cover_Type'\n",
    "\n",
    "print(\"dfdata.shape = \",dfdata.shape)\n",
    "print(\"target_col = \", target_col)\n",
    "print('cat_cols = ', cat_cols)  \n",
    "print('num_cols = ', num_cols[:3]+['...'])\n",
    "\n",
    "dftmp, dftest_raw = train_test_split(dfdata, random_state=42, test_size=0.2)\n",
    "dftrain_raw, dfval_raw = train_test_split(dftmp, random_state=42, test_size=0.2)\n",
    "\n",
    "print(\"len(dftrain) = \",len(dftrain_raw))\n",
    "print(\"len(dfval) = \",len(dfval_raw))\n",
    "print(\"len(dftest) = \",len(dftest_raw))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "169703c2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0be04fb536be45b197c4914168e34ea7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/2 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from torchkeras.tabular import TabularPreprocessor\n",
    "from sklearn.preprocessing import OrdinalEncoder\n",
    "\n",
    "#特征工程\n",
    "pipe = TabularPreprocessor(cat_features = cat_cols, \n",
    "                           embedding_features=cat_cols)\n",
    "encoder = OrdinalEncoder()\n",
    "\n",
    "dftrain = pipe.fit_transform(dftrain_raw.drop(target_col,axis=1))\n",
    "dftrain[target_col] = encoder.fit_transform(\n",
    "    dftrain_raw[target_col].values.reshape(-1,1)).astype(np.int32)\n",
    "\n",
    "dfval = pipe.transform(dfval_raw.drop(target_col,axis=1))\n",
    "dfval[target_col] = encoder.transform(\n",
    "    dfval_raw[target_col].values.reshape(-1,1)).astype(np.int32)\n",
    "\n",
    "dftest = pipe.transform(dftest_raw.drop(target_col,axis=1))\n",
    "dftest[target_col] = encoder.transform(\n",
    "    dftest_raw[target_col].values.reshape(-1,1)).astype(np.int32)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7768b968",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from torchkeras.tabular import TabularDataset\n",
    "from torch.utils.data import Dataset,DataLoader \n",
    "\n",
    "def get_dataset(dfdata):\n",
    "    return TabularDataset(\n",
    "                data = dfdata,\n",
    "                task = 'multiclass', #regression, binary, multiclass\n",
    "                target = [target_col],\n",
    "                continuous_cols = pipe.get_numeric_features(),\n",
    "                categorical_cols = pipe.get_embedding_features()\n",
    "        )\n",
    "\n",
    "def get_dataloader(ds,batch_size=1024,num_workers=0,shuffle=False):\n",
    "    dl = DataLoader(\n",
    "            ds,\n",
    "            batch_size=batch_size,\n",
    "            shuffle=shuffle,\n",
    "            num_workers=num_workers,\n",
    "            pin_memory=False,\n",
    "        )\n",
    "    return dl \n",
    "    \n",
    "ds_train = get_dataset(dftrain)\n",
    "ds_val = get_dataset(dfval)\n",
    "ds_test = get_dataset(dftest)\n",
    "\n",
    "dl_train = get_dataloader(ds_train,shuffle=True)\n",
    "dl_val = get_dataloader(ds_val,shuffle=False)\n",
    "dl_test = get_dataloader(ds_test,shuffle=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ec009434",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for batch in dl_train:\n",
    "    break\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb2f0170",
   "metadata": {},
   "source": [
    "## 二，定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "767468ab",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型配置:\n",
      "categorical_cardinality = [4, 40]\n",
      "embedding_dims = [(4, 2), (40, 20)]\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "import random\n",
    "from copy import deepcopy\n",
    "from dataclasses import dataclass, field\n",
    "from typing import Any, List, Literal, NamedTuple, Optional, Tuple, Union\n",
    "import torch \n",
    "from torch import Tensor\n",
    "from torch import nn \n",
    "import tabm \n",
    "from torchkeras.tabular.config import ModelConfig\n",
    "\n",
    "@dataclass\n",
    "class TabMConfig(ModelConfig):\n",
    "    k: int = field(\n",
    "        default=32,\n",
    "        metadata={\"help\": \"Number of parallel predictions to make (default: 32)\"}\n",
    "    )\n",
    "    n_blocks: int = field(\n",
    "        default=3,\n",
    "        metadata={\"help\": \"Number of Linear blocks in Tabm (default: 3)\"}\n",
    "    )\n",
    "    d_block: int = field(\n",
    "        default=512,\n",
    "        metadata={\"help\": \"Dimension of block in Tabm (default: 512)\"}\n",
    "    )\n",
    "    \n",
    "    plr_embed_dim: int = field(\n",
    "            default=64,\n",
    "            metadata={\"help\": \"The embedding dimension of the PLREmbedding. Defaults to 64\"},\n",
    "    )\n",
    "    \n",
    "    plr_frequencies_num: int = field(\n",
    "            default=96,\n",
    "            metadata={\"help\": \"The n_frequencies of the PLREmbedding. Defaults to 96\"},\n",
    "    )\n",
    "    \n",
    "    plr_frequency_scale: float = field(\n",
    "            default=0.013675285379929491,\n",
    "            metadata={\"help\": \"The frequency_scale of the PLREmbedding. Defaults to 0.013675285379929491\"},\n",
    "    )\n",
    "    dropout: float = field(default=0.1)\n",
    "    scaling_init: str = field(default=\"normal\")\n",
    "    _module_src: str = field(default=\"models.tabm\")\n",
    "    _model_name: str = field(default=\"TabMModel\")\n",
    "    _config_name: str = field(default=\"TabMConfig\")\n",
    "\n",
    "\n",
    "class CatEmbeddings(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        categorical_embedding_dims,\n",
    "        embedding_dropout = 0.0,\n",
    "    ):\n",
    "        super().__init__()\n",
    "        self.categorical_embedding_dims = categorical_embedding_dims\n",
    "        self.cat_embedding_layers = nn.ModuleList(\n",
    "            [nn.Embedding(x, y) for x, y in categorical_embedding_dims])\n",
    "        if embedding_dropout > 0:\n",
    "            self.embd_dropout = nn.Dropout(embedding_dropout)\n",
    "        else:\n",
    "            self.embd_dropout = None\n",
    "\n",
    "    def forward(self, x):\n",
    "        # (B, N)\n",
    "        x_cat = x\n",
    "        assert x_cat.shape[1] == len(\n",
    "            self.cat_embedding_layers\n",
    "        ), \"categorical_data must have same number of columns as categorical embedding layers\"\n",
    "        if x_cat.shape[1] > 0:\n",
    "            embed = torch.cat(\n",
    "                [\n",
    "                    embedding_layer(x_cat[:, i])\n",
    "                    for i, embedding_layer in enumerate(self.cat_embedding_layers)\n",
    "                ],\n",
    "                dim=1,\n",
    "            )\n",
    "        else:\n",
    "            embed = torch.empty(0, 0)\n",
    "        if self.embd_dropout is not None:\n",
    "            embed = self.embd_dropout(embed)\n",
    "        return embed\n",
    "    \n",
    "class PeriodicEmbeddings(nn.Module):\n",
    "    def __init__(\n",
    "        self, n_features: int, n_frequencies: int, frequency_scale: float\n",
    "    ) -> None:\n",
    "        super().__init__()\n",
    "        self.frequencies = nn.Parameter(\n",
    "            torch.normal(0.0, frequency_scale, (n_features, n_frequencies))\n",
    "        )\n",
    "    def forward(self, x: Tensor) -> Tensor:\n",
    "        assert x.ndim == 2\n",
    "        x = 2 * torch.pi * self.frequencies[None] * x[..., None]\n",
    "        x = torch.cat([torch.cos(x), torch.sin(x)], -1)\n",
    "        return x\n",
    "\n",
    "\n",
    "class PLREmbeddings(nn.Sequential):\n",
    "    def __init__(\n",
    "        self,\n",
    "        n_features: int,\n",
    "        n_frequencies: int,\n",
    "        frequency_scale: float,\n",
    "        d_embedding: int,\n",
    "    ) -> None:\n",
    "        super().__init__(\n",
    "            PeriodicEmbeddings(n_features, n_frequencies, frequency_scale),\n",
    "            nn.Linear(2 * n_frequencies, d_embedding),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "\n",
    "\n",
    "class TabMModel(nn.Module):\n",
    "    def __init__(self, config, **kwargs):\n",
    "        super().__init__()\n",
    "        self.hparams = config\n",
    "        \n",
    "        d_numerical = self.hparams.continuous_dim\n",
    "        categories = self.hparams.categorical_cardinality\n",
    "        n_classes = self.hparams.output_dim\n",
    "        d_out = n_classes if n_classes is not None else 1\n",
    "        d_block = self.hparams.d_block\n",
    "        n_blocks = self.hparams.n_blocks\n",
    "        dropout = self.hparams.dropout\n",
    "        k = self.hparams.k\n",
    "        scaling_init = self.hparams.scaling_init\n",
    "\n",
    "        self.cat_embeddings = CatEmbeddings(\n",
    "            categorical_embedding_dims = self.hparams.embedding_dims\n",
    "        ) if categories else None\n",
    "        \n",
    "        self.num_embeddings = PLREmbeddings(\n",
    "            n_features = d_numerical,\n",
    "            n_frequencies = self.hparams.plr_frequencies_num,\n",
    "            frequency_scale = self.hparams.plr_frequency_scale,\n",
    "            d_embedding = self.hparams.plr_embed_dim\n",
    "        ) if d_numerical>0 else None\n",
    "\n",
    "        d_in = d_numerical * self.hparams.plr_embed_dim + self.hparams.embedded_cat_dim\n",
    "        self.tabm_core = nn.Sequential(\n",
    "            tabm.EnsembleView(k=k),   # (B, d_in) -> (B, k, d_in)\n",
    "            tabm.MLPBackboneBatchEnsemble(\n",
    "                d_in=d_in,\n",
    "                n_blocks=n_blocks,\n",
    "                d_block=d_block,\n",
    "                dropout=dropout,\n",
    "                k=k,\n",
    "                tabm_init=True,\n",
    "                scaling_init=scaling_init,\n",
    "                start_scaling_init_chunks=None\n",
    "            ),\n",
    "            tabm.LinearEnsemble(512, d_out, k=k) # -> (B, k, d_out)\n",
    "        )\n",
    "        self.loss = getattr(nn, self.hparams.loss)()\n",
    "\n",
    "\n",
    "    def forward(self, inputs):\n",
    "        x_cat,x_num = inputs[\"categorical\"], inputs[\"continuous\"]\n",
    "        x = []\n",
    "        if self.num_embeddings is not None:\n",
    "            x.append(\n",
    "                x_num\n",
    "                if self.num_embeddings is None\n",
    "                else self.num_embeddings(x_num).flatten(1)\n",
    "            )\n",
    "            \n",
    "        if self.cat_embeddings is not None:\n",
    "            x.append(self.cat_embeddings(x_cat))\n",
    "\n",
    "        x = torch.cat(x, dim=1)\n",
    "        logits = self.tabm_core(x)\n",
    "        \n",
    "        with torch.no_grad():\n",
    "            if self.hparams.task == 'binary':\n",
    "                probs = torch.sigmoid(logits)\n",
    "            elif self.hparams.task == 'multiclass':\n",
    "                probs = torch.softmax(logits, dim=-1)\n",
    "            else:\n",
    "                probs = logits\n",
    "            yhat = probs.mean(1)\n",
    "\n",
    "        return {\"logits\": logits, \"yhat\":yhat}\n",
    "\n",
    "    def compute_loss(self, output, target):\n",
    "        y_pred = output[\"logits\"]\n",
    "        # TabM产生k个预测，需要分别训练\n",
    "        # 回归: (batch_size, k) -> (batch_size * k,)\n",
    "        # 分类: (batch_size, k, n_classes) -> (batch_size * k, n_classes)\n",
    "        y_pred = y_pred.flatten(0, 1)\n",
    "        # 复制目标以匹配预测的形状\n",
    "        # (batch_size,) -> (batch_size * k,)\n",
    "        y_true = target.repeat_interleave(self.hparams.k)\n",
    "        computed_loss = self.loss(y_pred.squeeze(), y_true.squeeze())\n",
    "        return computed_loss\n",
    "    \n",
    "    \n",
    "    def predict(self, batch):\n",
    "        self.eval()\n",
    "        output = self.forward(batch)\n",
    "        return output['yhat']\n",
    "    \n",
    "\n",
    "# 配置模型\n",
    "model_config = TabMConfig(\n",
    "    task=\"multiclass\",  #regression, binary, multiclass\n",
    "    k=32\n",
    ")\n",
    "\n",
    "# 合并数据集配置\n",
    "config = model_config.merge_dataset_config(ds_train)\n",
    "\n",
    "print('模型配置:')\n",
    "print('categorical_cardinality =', config.categorical_cardinality)\n",
    "print('embedding_dims =', config.embedding_dims)\n",
    "\n",
    "# 初始化模型\n",
    "net = TabMModel(config=config)\n",
    "\n",
    "print(net.hparams.output_dim)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7e312c76",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(1.9471, grad_fn=<NllLossBackward0>)\n"
     ]
    }
   ],
   "source": [
    "output = net.forward(batch)\n",
    "loss = net.compute_loss(output,batch['target'])\n",
    "print(loss)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22001eaf",
   "metadata": {},
   "source": [
    "## 三，训练模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "14bb01e8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from torchkeras import KerasModel \n",
    "from torchkeras.tabular import StepRunner \n",
    "KerasModel.StepRunner = StepRunner \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "780167c1",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import torch \n",
    "from torch import nn \n",
    "class Accuracy(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        self.correct = nn.Parameter(torch.tensor(0.0),requires_grad=False)\n",
    "        self.total = nn.Parameter(torch.tensor(0.0),requires_grad=False)\n",
    "\n",
    "    def forward(self, preds: torch.Tensor, targets: torch.Tensor):\n",
    "        preds = preds.argmax(dim=-1)\n",
    "        targets = targets.reshape(-1)\n",
    "        m = (preds == targets).sum()\n",
    "        n = targets.shape[0] \n",
    "        self.correct += m \n",
    "        self.total += n\n",
    "        \n",
    "        return m/n\n",
    "\n",
    "    def compute(self):\n",
    "        return self.correct.float() / self.total \n",
    "    \n",
    "    def reset(self):\n",
    "        self.correct -= self.correct\n",
    "        self.total -= self.total\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d3c69f48",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "keras_model = KerasModel(net,\n",
    "                   loss_fn=None,\n",
    "                   optimizer = torch.optim.AdamW(net.parameters(),lr = 1e-3),\n",
    "                   metrics_dict = {\"acc\":Accuracy()}\n",
    "                   )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "08f4ad31",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Detected kernel version 4.18.0, which is below the recommended minimum of 5.5.0; this can cause the process to hang. It is recommended to upgrade the kernel to the minimum version or higher.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[0;31m<<<<<< ⚡️ cuda is used >>>>>>\u001b[0m\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "<style>\n",
       "    /* background: */\n",
       "    progress::-webkit-progress-bar {background-color: #CDCDCD; width: 100%;}\n",
       "    progress {background-color: #CDCDCD;}\n",
       "\n",
       "    /* value: */\n",
       "    progress::-webkit-progress-value {background-color: #00BFFF  !important;}\n",
       "    progress::-moz-progress-bar {background-color: #00BFFF  !important;}\n",
       "    progress {color: #00BFFF ;}\n",
       "\n",
       "    /* optional */\n",
       "    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "        background: #000000;\n",
       "    }\n",
       "</style>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      <progress value='30' class='' max='30' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100% [30/30] [12:50]\n",
       "      <br>\n",
       "      ████████████████████100.00% [91/91] [val_loss=0.1828, val_acc=0.9390]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>train_acc</th>\n",
       "      <th>lr</th>\n",
       "      <th>val_loss</th>\n",
       "      <th>val_acc</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>0.706615</td>\n",
       "      <td>0.711688</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.522979</td>\n",
       "      <td>0.780545</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>0.498825</td>\n",
       "      <td>0.801983</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.430890</td>\n",
       "      <td>0.829801</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>0.433016</td>\n",
       "      <td>0.838444</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.372017</td>\n",
       "      <td>0.856866</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4</td>\n",
       "      <td>0.391631</td>\n",
       "      <td>0.860443</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.337021</td>\n",
       "      <td>0.874346</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5</td>\n",
       "      <td>0.362974</td>\n",
       "      <td>0.875981</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.312029</td>\n",
       "      <td>0.882952</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>6</td>\n",
       "      <td>0.342666</td>\n",
       "      <td>0.886711</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.293012</td>\n",
       "      <td>0.893752</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>7</td>\n",
       "      <td>0.326724</td>\n",
       "      <td>0.894201</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.276800</td>\n",
       "      <td>0.901110</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>8</td>\n",
       "      <td>0.313918</td>\n",
       "      <td>0.901196</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.262480</td>\n",
       "      <td>0.906747</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>9</td>\n",
       "      <td>0.304360</td>\n",
       "      <td>0.905975</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.254953</td>\n",
       "      <td>0.910383</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>10</td>\n",
       "      <td>0.295499</td>\n",
       "      <td>0.909828</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.244781</td>\n",
       "      <td>0.914470</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>11</td>\n",
       "      <td>0.288480</td>\n",
       "      <td>0.913427</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.242002</td>\n",
       "      <td>0.916891</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>12</td>\n",
       "      <td>0.281373</td>\n",
       "      <td>0.916466</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.230420</td>\n",
       "      <td>0.919957</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>13</td>\n",
       "      <td>0.276510</td>\n",
       "      <td>0.919225</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.225649</td>\n",
       "      <td>0.923345</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>14</td>\n",
       "      <td>0.271782</td>\n",
       "      <td>0.921616</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.224667</td>\n",
       "      <td>0.924518</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>15</td>\n",
       "      <td>0.267696</td>\n",
       "      <td>0.923393</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.218876</td>\n",
       "      <td>0.925184</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>16</td>\n",
       "      <td>0.264132</td>\n",
       "      <td>0.924781</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.214100</td>\n",
       "      <td>0.927304</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>17</td>\n",
       "      <td>0.260238</td>\n",
       "      <td>0.926577</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.214523</td>\n",
       "      <td>0.929100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>18</td>\n",
       "      <td>0.256917</td>\n",
       "      <td>0.928473</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.208556</td>\n",
       "      <td>0.929595</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>19</td>\n",
       "      <td>0.254207</td>\n",
       "      <td>0.929057</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.204095</td>\n",
       "      <td>0.930488</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>20</td>\n",
       "      <td>0.251627</td>\n",
       "      <td>0.930173</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.200359</td>\n",
       "      <td>0.933252</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>21</td>\n",
       "      <td>0.248984</td>\n",
       "      <td>0.931335</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.198660</td>\n",
       "      <td>0.932650</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>22</td>\n",
       "      <td>0.246792</td>\n",
       "      <td>0.932491</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.196486</td>\n",
       "      <td>0.934844</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>23</td>\n",
       "      <td>0.244630</td>\n",
       "      <td>0.933653</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.195056</td>\n",
       "      <td>0.935189</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>24</td>\n",
       "      <td>0.242817</td>\n",
       "      <td>0.934234</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.191842</td>\n",
       "      <td>0.935716</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>25</td>\n",
       "      <td>0.240670</td>\n",
       "      <td>0.935057</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.190785</td>\n",
       "      <td>0.937243</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>26</td>\n",
       "      <td>0.238935</td>\n",
       "      <td>0.935874</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.189366</td>\n",
       "      <td>0.938071</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>27</td>\n",
       "      <td>0.237022</td>\n",
       "      <td>0.936977</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.189844</td>\n",
       "      <td>0.937211</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>28</td>\n",
       "      <td>0.235384</td>\n",
       "      <td>0.937275</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.185007</td>\n",
       "      <td>0.938523</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>29</td>\n",
       "      <td>0.234195</td>\n",
       "      <td>0.937714</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.184567</td>\n",
       "      <td>0.938147</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>30</td>\n",
       "      <td>0.232908</td>\n",
       "      <td>0.938429</td>\n",
       "      <td>0.001</td>\n",
       "      <td>0.182811</td>\n",
       "      <td>0.938964</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    epoch  train_loss  train_acc     lr  val_loss   val_acc\n",
       "0       1    0.706615   0.711688  0.001  0.522979  0.780545\n",
       "1       2    0.498825   0.801983  0.001  0.430890  0.829801\n",
       "2       3    0.433016   0.838444  0.001  0.372017  0.856866\n",
       "3       4    0.391631   0.860443  0.001  0.337021  0.874346\n",
       "4       5    0.362974   0.875981  0.001  0.312029  0.882952\n",
       "5       6    0.342666   0.886711  0.001  0.293012  0.893752\n",
       "6       7    0.326724   0.894201  0.001  0.276800  0.901110\n",
       "7       8    0.313918   0.901196  0.001  0.262480  0.906747\n",
       "8       9    0.304360   0.905975  0.001  0.254953  0.910383\n",
       "9      10    0.295499   0.909828  0.001  0.244781  0.914470\n",
       "10     11    0.288480   0.913427  0.001  0.242002  0.916891\n",
       "11     12    0.281373   0.916466  0.001  0.230420  0.919957\n",
       "12     13    0.276510   0.919225  0.001  0.225649  0.923345\n",
       "13     14    0.271782   0.921616  0.001  0.224667  0.924518\n",
       "14     15    0.267696   0.923393  0.001  0.218876  0.925184\n",
       "15     16    0.264132   0.924781  0.001  0.214100  0.927304\n",
       "16     17    0.260238   0.926577  0.001  0.214523  0.929100\n",
       "17     18    0.256917   0.928473  0.001  0.208556  0.929595\n",
       "18     19    0.254207   0.929057  0.001  0.204095  0.930488\n",
       "19     20    0.251627   0.930173  0.001  0.200359  0.933252\n",
       "20     21    0.248984   0.931335  0.001  0.198660  0.932650\n",
       "21     22    0.246792   0.932491  0.001  0.196486  0.934844\n",
       "22     23    0.244630   0.933653  0.001  0.195056  0.935189\n",
       "23     24    0.242817   0.934234  0.001  0.191842  0.935716\n",
       "24     25    0.240670   0.935057  0.001  0.190785  0.937243\n",
       "25     26    0.238935   0.935874  0.001  0.189366  0.938071\n",
       "26     27    0.237022   0.936977  0.001  0.189844  0.937211\n",
       "27     28    0.235384   0.937275  0.001  0.185007  0.938523\n",
       "28     29    0.234195   0.937714  0.001  0.184567  0.938147\n",
       "29     30    0.232908   0.938429  0.001  0.182811  0.938964"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keras_model.fit(\n",
    "    train_data = dl_train,\n",
    "    val_data= dl_val,\n",
    "    ckpt_path='checkpoint',\n",
    "    epochs=30,\n",
    "    patience=10,\n",
    "    monitor=\"val_acc\", \n",
    "    mode=\"max\",\n",
    "    plot = True,\n",
    "    wandb = False\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "092528f3",
   "metadata": {},
   "source": [
    "## 四，评估模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "15693dba",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████| 364/364 [00:15<00:00, 23.30it/s, val_acc=0.947, val_loss=0.165]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'val_loss': 0.1648734294614949, 'val_acc': 0.9472041130065918}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keras_model.evaluate(dl_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4f52f49a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████| 91/91 [00:03<00:00, 24.70it/s, val_acc=0.939, val_loss=0.183]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'val_loss': 0.1828107291853035, 'val_acc': 0.938964307308197}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keras_model.evaluate(dl_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6050f49a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████| 114/114 [00:04<00:00, 23.02it/s, val_acc=0.939, val_loss=0.181]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'val_loss': 0.18126998371199557, 'val_acc': 0.9390290975570679}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keras_model.evaluate(dl_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ced7f651",
   "metadata": {},
   "source": [
    "## 五，使用模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0c3f0dd5",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 114/114 [01:04<00:00,  1.77it/s]\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm \n",
    "net = net.cpu()\n",
    "net.eval()\n",
    "preds = []\n",
    "with torch.no_grad():\n",
    "    for batch in tqdm(dl_test):\n",
    "        preds.append(net.predict(batch))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e330d9f7",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "yhat_list = [yd.argmax(dim=-1).tolist() for yd in preds]\n",
    "yhat = []\n",
    "for yd in yhat_list:\n",
    "    yhat.extend(yd)\n",
    "yhat = encoder.inverse_transform(np.array(yhat).reshape(-1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ac0b9cad",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dftest_raw = dftest_raw.rename(columns = {target_col: 'y'})\n",
    "dftest_raw['yhat'] = yhat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "7cd623c7",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1       0.95      0.92      0.94     42557\n",
      "           2       0.94      0.96      0.95     56500\n",
      "           3       0.93      0.96      0.94      7121\n",
      "           4       0.91      0.79      0.85       526\n",
      "           5       0.86      0.83      0.84      1995\n",
      "           6       0.90      0.89      0.89      3489\n",
      "           7       0.94      0.94      0.94      4015\n",
      "\n",
      "    accuracy                           0.94    116203\n",
      "   macro avg       0.92      0.90      0.91    116203\n",
      "weighted avg       0.94      0.94      0.94    116203\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "print(classification_report(y_true = dftest_raw['y'],y_pred = dftest_raw['yhat']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "75b5f2ee",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "\n",
    "# 计算混淆矩阵\n",
    "cm = confusion_matrix(dftest_raw['y'], dftest_raw['yhat'])\n",
    "\n",
    "# 将混淆矩阵转换为DataFrame\n",
    "df_cm = pd.DataFrame(cm, index=['Actual {}'.format(i) for i in range(cm.shape[0])],\n",
    "                     columns=['Predicted {}'.format(i) for i in range(cm.shape[1])])\n",
    "\n",
    "# 使用seaborn绘制混淆矩阵\n",
    "plt.figure(figsize=(10,7))\n",
    "sns.heatmap(df_cm, annot=True, fmt='d', cmap='Blues', cbar=False)\n",
    "plt.title('Confusion Matrix')\n",
    "plt.xlabel('Predicted labels')\n",
    "plt.ylabel('True labels')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bd458bc",
   "metadata": {},
   "source": [
    "## 六，保存模型"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84fd68e5",
   "metadata": {},
   "source": [
    "最佳模型权重已经保存在ckpt_path = 'checkpoint'位置了。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "039d1fd4",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net.load_state_dict(torch.load('checkpoint',weights_only=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6af119bc",
   "metadata": {},
   "source": [
    "## 七，与LightGBM对比"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "5a217aa4",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LightGBM] [Info] Auto-choosing row-wise multi-threading, the overhead of testing was 0.014433 seconds.\n",
      "You can set `force_row_wise=true` to remove the overhead.\n",
      "And if memory is not enough, you can set `force_col_wise=true`.\n",
      "[LightGBM] [Info] Total Bins 2219\n",
      "[LightGBM] [Info] Number of data points in the train set: 371847, number of used features: 12\n",
      "[LightGBM] [Info] Start training from score -1.009334\n",
      "[LightGBM] [Info] Start training from score -0.717530\n",
      "[LightGBM] [Info] Start training from score -2.789050\n",
      "[LightGBM] [Info] Start training from score -5.354306\n",
      "[LightGBM] [Info] Start training from score -4.127223\n",
      "[LightGBM] [Info] Start training from score -3.510637\n",
      "[LightGBM] [Info] Start training from score -3.341909\n",
      "Training until validation scores don't improve for 50 rounds\n",
      "Did not meet early stopping. Best iteration is:\n",
      "[500]\tvalidate's multi_logloss: 0.408343\n",
      "val_score =  0.8321464684494739\n",
      "test_score =  0.8329389086340284\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd \n",
    "import lightgbm as lgb\n",
    "from sklearn.preprocessing import OrdinalEncoder\n",
    "from sklearn.metrics import accuracy_score \n",
    "\n",
    "\n",
    "dftmp, dftest_raw = train_test_split(dfdata, random_state=42, test_size=0.2)\n",
    "dftrain_raw, dfval_raw = train_test_split(dftmp, random_state=42, test_size=0.2)\n",
    "\n",
    "dftrain = dftrain_raw.copy()\n",
    "dfval = dfval_raw.copy()\n",
    "dftest = dftest_raw.copy()\n",
    "\n",
    "target_col = 'Cover_Type'\n",
    "cat_cols = ['Wilderness_Area', 'Soil_Type']\n",
    "\n",
    "encoder = OrdinalEncoder()\n",
    "\n",
    "dftrain[target_col] = encoder.fit_transform(dftrain[target_col].values.reshape(-1,1)) \n",
    "dfval[target_col] = encoder.transform(dfval[target_col].values.reshape(-1,1))\n",
    "dftest[target_col] = encoder.transform(dftest[target_col].values.reshape(-1,1))\n",
    "\n",
    "for col in cat_cols:\n",
    "    dftrain[col] = dftrain[col].astype(int)\n",
    "    dfval[col] = dfval[col].astype(int)\n",
    "    dftest[col] = dftest[col].astype(int)\n",
    "\n",
    "ds_train = lgb.Dataset(dftrain.drop(columns=[target_col]), label=dftrain[target_col],categorical_feature=cat_cols)\n",
    "ds_val = lgb.Dataset(dfval.drop(columns=[target_col]), label=dfval[target_col],categorical_feature=cat_cols)\n",
    "ds_test = lgb.Dataset(dftest.drop(columns=[target_col]), label=dftest[target_col],categorical_feature=cat_cols)\n",
    "\n",
    "\n",
    "import lightgbm as lgb\n",
    "\n",
    "params = {\n",
    "    'n_estimators':500,\n",
    "    'boosting_type': 'gbdt',\n",
    "    'objective':'multiclass',\n",
    "    'num_class': 7,  # 类别数量\n",
    "    'metric': 'multi_logloss', \n",
    "    'learning_rate': 0.01,\n",
    "    'verbose': 1,\n",
    "    'early_stopping_round':50\n",
    "}\n",
    "model = lgb.train(params, ds_train, \n",
    "        valid_sets=[ds_val], \n",
    "        valid_names=['validate']\n",
    "        )\n",
    "\n",
    "y_pred_val = model.predict(dfval.drop(target_col,axis = 1), num_iteration=model.best_iteration)\n",
    "y_pred_val = np.argmax(y_pred_val, axis=1)\n",
    "\n",
    "y_pred_test = model.predict(dftest.drop(target_col,axis = 1), num_iteration=model.best_iteration)\n",
    "y_pred_test = np.argmax(y_pred_test, axis=1)\n",
    "\n",
    "val_score = accuracy_score(dfval[target_col], y_pred_val)\n",
    "test_score = accuracy_score(dftest[target_col], y_pred_test) \n",
    "\n",
    "print('val_score = ',val_score)\n",
    "print('test_score = ' , test_score)"
   ]
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "gpu",
   "dataSources": [],
   "dockerImageVersionId": 30747,
   "isGpuEnabled": true,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "kernelspec": {
   "display_name": "deeplearning",
   "language": "python",
   "name": "deeplearning"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
